home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 15 / BBS in a box XV-2.iso / Files II / Prog / T / TransSkel 3.11.sit / TransSkel v 3.11 / Interface / TransSkel.intf < prev    next >
Encoding:
Text File  |  1994-02-23  |  11.7 KB  |  353 lines  |  [TEXT/PJMM]
  1. { Pascal interface specification for TransSkel }
  2. { for:       TransSkel 3.11 }
  3. { last edit: 18 Feb 94 }
  4.  
  5. {----------------------------------------------------------------------------}
  6. unit TransSkel;
  7. {----------------------------------------------------------------------------}
  8.  
  9. interface
  10. {----------------------------------------------------------------------------}
  11.     const
  12. {----------------------------------------------------------------------------}
  13.  
  14. { general }
  15.  
  16.         skelMajorRelease = 3;            { current release is 3.11 }
  17.         skelMinorRelease = 11;
  18.  
  19. { window property numbers }
  20.  
  21.         skelWPropAll = 0;                { pseudo-property }
  22.         skelWPropModeless = 1;            { modeless dialog }
  23.         skelWPropModal = 2;                { modal dialog }
  24.         skelWPropTool = 3;                { tool window }
  25.         skelWPropMovableModal = 4;        { movable modal dialog }
  26.         skelWPropHelp = 5;                { help window }
  27.         skelWPropText = 6;                { text window }
  28.         skelWPropDisplayWind = 7;        { TransDisplay window }
  29.         skelWPropEditWind = 8;            { TransEdit window }
  30.         skelWPropApplBase = 256;        { general-use prop num base }
  31.  
  32. { SkelQuery () query selectors }
  33.  
  34.         skelQVersion = 1;                { TransSkel version }
  35.         skelQSysVersion = 2;            { System software version }
  36.         skelQHasWNE = 3;                { whether has WaitNextEvent() }
  37.         skelQMBarHeight = 4;            { menu bar height }
  38.         skelQHas64KROM = 5;                { whether has 64K ROM }
  39.         skelQHasColorQD = 6;            { whether has Color QuickDraw }
  40.         skelQInForeground = 7;            { whether in foreground }
  41.         skelQHasGestalt = 8;            { whether has Gestalt() }
  42.         skelQHasAppleEvents = 9;        { whether has Apple Events }
  43.         skelQQDVersion = 10;            { QuickDraw version }
  44.         skelQGrayRgn = 11;                { Desktop region }
  45.  
  46. { convenience routines }
  47.  
  48.         skelPositionNone = 0;            { leave as is }
  49.         skelPositionOnMainDevice = 1;    { position on main device }
  50.         skelPositionOnParentWindow = 2;    { position on FrontWindow() }
  51.         skelPositionOnParentDevice = 3;    { position on FrontWindow()'s device }
  52.  
  53. { Apple menu number }
  54.  
  55.         skelAppleMenuID = 128;
  56.  
  57.  
  58. {----------------------------------------------------------------------------}
  59.     type
  60. {----------------------------------------------------------------------------}
  61.  
  62. { window property types }
  63.  
  64.         SkelWindPropPtr = ^SkelWindProperty;
  65.         SkelWindPropHandle = ^SkelWindPropPtr;
  66.         SkelWindProperty = record
  67.                 skelWPropType: Integer;
  68.                 skelWPropData: LongInt;
  69.                 skelWPropNext: SkelWindPropHandle;
  70.             end;
  71.  
  72. { initialization parameters }
  73.  
  74.         SkelInitParamsPtr = ^SkelInitParams;
  75.         SkelInitParams = record
  76.                 skelMoreMasters: Integer;
  77.                 skelGzProc: ProcPtr;
  78.                 skelResumeProc: ProcPtr;
  79.                 skelStackAdjust: Size;
  80.             end;
  81.  
  82. { Procedure types below are all equivalenced to ProcPtr. They're used so }
  83. { that procedure/function specifications will read more similarly to their }
  84. { C counterparts.  The comment preceding each type definition shows how }
  85. { procedures should be written. }
  86.  
  87. { miscellaneous procedure types }
  88.  
  89.         { procedure Idle; }
  90.         SkelIdleProcPtr = ProcPtr;
  91.         { procedure EventHook (event: EventRecord); }
  92.         SkelEventHookProcPtr = ProcPtr;
  93.         { procedure SuspendResume (inForeground: Boolean); }
  94.         SkelSuspendResumeProcPtr = ProcPtr;
  95.         { procedure ClipCvt (inForeground: Boolean); }
  96.         SkelClipCvtProcPtr = ProcPtr;
  97.         { procedure AEHandler (event: EventRecord); }
  98.         SkelAEHandlerProcPtr = ProcPtr;
  99.         { procedure DlogItemProc (dlog: DialotPtr; item: Integer); }
  100.         SkelDlogItemProcPtr = ProcPtr;
  101.  
  102. { window-handler procedure types }
  103.  
  104.         { procedure Mouse (where: Point; when: LongInt; modifiers: Integer); }
  105.         SkelWindMouseProcPtr = ProcPtr;
  106.         { procedure Key (c: char; code: Integer; modifiers: Integer); }
  107.         SkelWindKeyProcPtr = ProcPtr;
  108.         { procedure Update (resized: Boolean); }
  109.         SkelWindUpdateProcPtr = ProcPtr;
  110.         { procedure Activate (active: Boolean); }
  111.         SkelWindActivateProcPtr = ProcPtr;
  112.         { procedure Close; }
  113.         SkelWindCloseProcPtr = ProcPtr;
  114.         { procedure Clobber; }
  115.         SkelWindClobberProcPtr = ProcPtr;
  116.         { procedure WindIdle; }
  117.         SkelWindIdleProcPtr = ProcPtr;
  118.  
  119.         { procedure Event(item:Integer; event: EventRecord); }
  120.         SkelWindEventProcPtr = ProcPtr;
  121.         { procedure Zoom (wind: WindowPtr; zoomDir: Integer); }
  122.         SkelWindZoomProcPtr = ProcPtr;
  123.  
  124. { menu-handler procedure types }
  125.  
  126.         { procedure Select (item: Integer); }
  127.         SkelMenuSelectProcPtr = ProcPtr;
  128.         { procedure Clobber (menu: MenuHandle); }
  129.         SkelMenuClobberProcPtr = ProcPtr;
  130.  
  131.         { procedure MenuHook; }
  132.         SkelMenuHookProcPtr = ProcPtr;
  133.  
  134.  
  135. {----------------------------------------------------------------------------}
  136. { Core routines }
  137. {----------------------------------------------------------------------------}
  138.  
  139. { initialization/termination routines }
  140.  
  141.     procedure SkelGetInitParams (initParams: SkelInitParamsPtr);
  142.     procedure SkelInit (initParams: SkelInitParamsPtr);
  143.     procedure SkelCleanup;
  144.  
  145. { event-loop-related routines }
  146.  
  147.     procedure SkelEventLoop;
  148.     procedure SkelStopEventLoop;
  149.     procedure SkelRouteEvent (event: EventRecord);    { really takes a pointer }
  150.     procedure SkelActivate (wind: WindowPtr;
  151.                                     active: Boolean);
  152.     procedure SkelClose (wind: WindowPtr);
  153.     function SkelGetCurrentEvent: EventRecord;        { really returns a pointer }
  154.     function SkelGetModifiers: Integer;
  155.     procedure SkelSetEventMask (mask: Integer);
  156.     function SkelGetEventMask: Integer;
  157.     procedure SkelSetDlogMask (mask: Integer);
  158.     function SkelGetDlogMask: Integer;
  159.     procedure SkelSetIdle (p: SkelIdleProcPtr);
  160.     function SkelGetIdle: SkelIdleProcPtr;
  161.     procedure SkelSetEventHook (p: SkelEventHookProcPtr);
  162.     function SkelGetEventHook: SkelEventHookProcPtr;
  163.     procedure SkelSetSuspendResume (p: SkelSuspendResumeProcPtr);
  164.     function SkelGetSuspendResume: SkelSuspendResumeProcPtr;
  165.     procedure SkelSetClipCvt (p: SkelClipCvtProcPtr);
  166.     function SkelGetClipCvt: SkelClipCvtProcPtr;
  167.     procedure SkelSetWaitTimes (fgTime: LongInt;
  168.                                     bgTime: LongInt);
  169.     procedure SkelGetWaitTimes (var fgTime: LongInt;
  170.                                     var bgTime: LongInt);
  171.  
  172.     procedure SkelSetAEHandler (p: SkelAEHandlerProcPtr);
  173.     function SkelGetAEHandler: SkelAEHandlerProcPtr;
  174.  
  175. { window handling routines }
  176.  
  177.     function SkelWindow (wind: WindowPtr;
  178.                                     doMouse: SkelWindMouseProcPtr;
  179.                                     doKey: SkelWindKeyProcPtr;
  180.                                     doUpdate: SkelWindUpdateProcPtr;
  181.                                     doActivate: SkelWindActivateProcPtr;
  182.                                     doClose: SkelWindCloseProcPtr;
  183.                                     doClobber: SkelWindClobberProcPtr;
  184.                                     doIdle: SkelWindIdleProcPtr;
  185.                                     frontOnly: Boolean): Boolean;
  186.     function SkelDialog (dlog: DialogPtr;
  187.                                     doEvent: SkelWindEventProcPtr;
  188.                                     doClose: SkelWindCloseProcPtr;
  189.                                     doClobber: SkelWindClobberProcPtr): Boolean;
  190.     procedure SkelRmveWind (wind: WindowPtr);
  191.     procedure SkelRmveDlog (dlog: DialogPtr);
  192.     function SkelWindowRegistered (wind: WindowPtr): Boolean;
  193.     procedure SkelSetGrowBounds (wind: WindowPtr;
  194.                                     hLo: Integer;
  195.                                     vLo: Integer;
  196.                                     hHi: Integer;
  197.                                     vHi: Integer);
  198.     procedure SkelSetZoom (wind: WindowPtr;
  199.                                     p: SkelWindZoomProcPtr);
  200.     function SkelGetZoom (wind: WindowPtr): SkelWindZoomProcPtr;
  201.     function SkelGetRectDevice (r: Rect;
  202.                                     var gd: GDHandle;
  203.                                     var devRect: Rect;
  204.                                     var isMain: Boolean): Boolean;
  205.     function SkelGetWindowDevice (wind: WindowPtr;
  206.                                     var gd: GDHandle;
  207.                                     var devRect: Rect): Boolean;
  208.     procedure SkelGetWindContentRect (wind: WindowPtr;
  209.                                     var r: Rect);
  210.     procedure SkelGetWindStructureRect (wind: WindowPtr;
  211.                                     var r: Rect);
  212.     function SkelGetWindTitleHeight (wind: WindowPtr): Integer;
  213.  
  214.     function SkelAddWindProp (w: WindowPtr;
  215.                                     propType: Integer;
  216.                                     propData: LongInt): Boolean;
  217.     procedure SkelRmveWindProp (w: WindowPtr;
  218.                                     propType: Integer);
  219.     function SkelGetWindProp (w: WindowPtr;
  220.                                     propType: Integer): SkelWindPropHandle;
  221.  
  222.  
  223.  
  224. { menu handling routines }
  225.  
  226.     function SkelMenu (menu: MenuHandle;
  227.                                     doSelect: SkelMenuSelectProcPtr;
  228.                                     doClobber: SkelMenuClobberProcPtr;
  229.                                     subMenu: Boolean;
  230.                                     drawMenuBar: Boolean): Boolean;
  231.     procedure SkelRmveMenu (menu: MenuHandle);
  232.  
  233.     procedure SkelSetMenuHook (p: SkelMenuHookProcPtr);
  234.     function SkelGetMenuHook: SkelMenuHookProcPtr;
  235.  
  236.  
  237. { environment information routines}
  238.  
  239.     function SkelQuery (selector: Integer): LongInt;
  240.     function SkelTrapAvailable (theTrap: Integer): Boolean;
  241.  
  242.  
  243. {----------------------------------------------------------------------------}
  244. { Auxiliary routines }
  245. {----------------------------------------------------------------------------}
  246.  
  247.     procedure SkelApple (items: Str255;
  248.                                     doSelect: SkelMenuSelectProcPtr);
  249.  
  250.     procedure SkelDoEvents (mask: Integer);
  251.     procedure SkelDoUpdates;
  252.  
  253.     function SkelDlogFilter (filter: ModalFilterProcPtr;
  254.                                     doReturn: Boolean): ModalFilterProcPtr;
  255.     function SkelDlogFilterYD (filter: ModalFilterYDProcPtr;
  256.                                     doReturn: Boolean): ModalFilterYDProcPtr;
  257.     procedure SkelRmveDlogFilter;
  258.     procedure SkelDlogDefaultItem (item: Integer);
  259.     procedure SkelDlogCancelItem (item: Integer);
  260.  
  261.     function SkelCmdPeriod (event: EventRecord): Boolean;    { param is really a pointer }
  262.  
  263.  
  264. {----------------------------------------------------------------------------}
  265. { Convenience routines }
  266. {----------------------------------------------------------------------------}
  267.  
  268.     procedure SkelGetMainDeviceRect (var r: Rect);
  269.     procedure SkelPositionRect (refRect: Rect;
  270.                                     var r: Rect;
  271.                                     hRatio: Fixed;
  272.                                     vRatio: Fixed);
  273.     procedure SkelGetReferenceRect (var r: Rect;
  274.                                     positionType: Integer);
  275.     procedure SkelPositionWindow (wind: WindowPtr;
  276.                                     positionType: Integer;
  277.                                     hRatio: Fixed;
  278.                                     vRatio: Fixed);
  279.     function SkelTestRectVisible (r: Rect): Boolean;
  280.  
  281. { alert presentation routines }
  282.  
  283.     function SkelAlert (alrtResNum: Integer;
  284.                                     filter: ModalFilterProcPtr;
  285.                                     positionType: Integer): Integer;
  286.     procedure SkelSetAlertPosRatios (hRatio: Fixed;
  287.                                     vRatio: Fixed);
  288.     procedure SkelGetAlertPosRatios (var hRatio: Fixed;
  289.                                     var vRatio: Fixed);
  290.  
  291. { control manipulation routines }
  292.  
  293.     function SkelHiliteControl (ctrl: ControlHandle;
  294.                                     hilite: Integer): Boolean;
  295.     procedure SkelDrawButtonOutline (ctrl: ControlHandle);
  296.     procedure SkelEraseButtonOutline (ctrl: ControlHandle);
  297.     procedure SkelFlashButton (ctrl: ControlHandle);
  298.     function SkelToggleCtlValue (ctrl: ControlHandle): Integer;
  299.  
  300. { dialog item manipulation routines }
  301.  
  302.     function SkelGetDlogCtl (dlog: DialogPtr;
  303.                                     item: Integer): ControlHandle;
  304.     function SkelSetDlogCtlHilite (dlog: DialogPtr;
  305.                                     item: Integer;
  306.                                     hilite: Integer): Boolean;
  307.     function SkelGetDlogCtlHilite (dlog: DialogPtr;
  308.                                     item: Integer): Integer;
  309.     procedure SkelSetDlogCtlValue (dlog: DialogPtr;
  310.                                     item: Integer;
  311.                                     value: Integer);
  312.     function SkelGetDlogCtlValue (dlog: DialogPtr;
  313.                                     item: Integer): Integer;
  314.     function SkelToggleDlogCtlValue (dlog: DialogPtr;
  315.                                     item: Integer): Integer;
  316.     procedure SkelSetDlogCtlRefCon (dlog: DialogPtr;
  317.                                     item: Integer;
  318.                                     value: LongInt);
  319.     function SkelGetDlogCtlRefCon (dlog: DialogPtr;
  320.                                     item: Integer): LongInt;
  321.     procedure SkelSetDlogStr (dlog: DialogPtr;
  322.                                     item: integer;
  323.                                     str: Str255);
  324.     procedure SkelGetDlogStr (dlog: DialogPtr;
  325.                                     item: integer;
  326.                                     var str: Str255);
  327.     procedure SkelSetDlogRect (dlog: DialogPtr;
  328.                                     item: integer;
  329.                                     r: Rect);
  330.     procedure SkelGetDlogRect (dlog: DialogPtr;
  331.                                     item: integer;
  332.                                     var r: Rect);
  333.     procedure SkelSetDlogProc (dlog: DialogPtr;
  334.                                     item: Integer;
  335.                                     p: SkelDlogItemProcPtr);
  336.     function SkelGetDlogProc (dlog: DialogPtr;
  337.                                     item: Integer): SkelDlogItemProcPtr;
  338.     procedure SkelSetDlogType (dlog: DialogPtr;
  339.                                     item: Integer;
  340.                                     itemType: Integer);
  341.     function SkelGetDlogType (dlog: DialogPtr;
  342.                                     item: Integer): Integer;
  343.     procedure SkelSetDlogRadioButtonSet (dlog: DialogPtr;
  344.                                     first: Integer;
  345.                                     last: Integer;
  346.                                     choice: Integer);
  347.     procedure SkelSetDlogButtonOutliner (dlog: DialogPtr;
  348.                                     item: Integer);
  349.  
  350.     procedure SkelPause (ticks: LongInt);
  351.  
  352. implementation
  353. end.